\begin{itemize}
	\item{\textbf{Acci\'on:}}
	El objetivo de la funci\'on es recortar un cuadrado de la imagen original de tama\~no ($tam$) a partir de un p\'ixel (x,y). Siendo el p\'ixel (0,0) el que se encuentra en la parte superior izquierda de la imagen.
	\item{\textbf{Prototipo:}}
	void $recortar$ (unsigned char* $src$, unsigned char* $dst$, int $h$, int $w$, int $src\_row\_size$, int $dst\_row\_size$, int $x$, int $y$, int $tam$)
	\item{\textbf{Procedimiento en C:}}
	Tomamos como punto inicial el introducido como par\'ametro ($x$,$y$). 
	A partir de ese punto, recorremos las filas y las columnas. 
	Para las columnas en cada iteraci\'on le vamos sumando 1 para avanzar hasta que lleguemos al pixel ($x$+$tam$). 
	Lo mismo hacemos para las filas, avanzamos filas hasta llegar al valor ($y$+$tam$). Para el c\'alculo de las filas le sumamos a $y$ nuestro contador de filas que es $j$ y a ese resultado lo multiplicamos por $src\_row\_size$ para avanzar hacia la fila que queremos.
	Por cada pixel que nos paramos lo escribimos en la imagen de salida pero no en la misma posici\'on que estaba en la imagen de entrada, sino que la imagen de salida empezamos a pegar los pixeles a partir de (0,0). En este algoritmo cada pixel es obtenido en una iteraci\'on distinta, no hay trabajo en paralelo. 
	\item{\textbf{Procedimiento en ASM:}}
	En este algoritmo, los par\'ametros $x$, $y$ y $tam$ est\'an cargados en la pila en [rsp+8], [rsp+16] y [rsp+24] antes de armar el stackFrame, por eso mismo nos guardamos en $rax$ el valor de $rsp$ antes de guardar los registros de la conveci\'on $C$.
	Hacemos un ciclo para recorrer las filas y por cada fila vamos recorriendo las columnas. 
	Primero calculamos en $rbx$ la ubicaci\'on de donde vamos a copiar los pixeles, para eso tomamos los puntos iniciales (x,y). 
	Para el c\'alculo de la fila, hacemos el mismo c\'alculo que en $C$, sumando al $y$ el contador de filas $r12$ y luego multiplicarlo por $src\_row\_size$, al resultado le sumamos el contador de columnas $r13$.
	A partir de esta posici\'on, nos traemos a $xmm0$ 16 pixeles de la imagen de entrada y los pegamos los 16 bytes en la imagen de salida. El lugar donde pegamos en la imagen de salida se calcula multiplicando el contador de filas por $dst\_row\_size$ y luego sumarle $r13$ que es el contador de columnas que vamos recorriendo.
	Cuando terminamos de copiar los 16 bytes en el destino, debemos fijarnos cu\'anto nos queda recorrer para aprovechar el paralelismo.
	Si nos quedas mas o 16 pixeles por columna lo hacemos sin inconvenientes, si nos resta recorrer menos de 16 pixeles retrocedemos la cantidad de pixeles de manera que la pr\'oxima iteraci\'on agarremos 16 pixeles de una misma fila. Para hacer esto lo que hacemos en la mayor\'ia de las funciones es ir retrocediendo de a 1 pixel y fijarnos si nos faltan 16 pixeles por recorrer, en caso que esta igual todav\'ia no se satisfaga retrocedemos nuevamente 1 pixel hasta que nos queden 16 pixeles exactos.
	El algoritmo utiliza paralelismo y por cada iteraci\'on trabaja con 16 pixeles, copiando los mismos y escribiendo 16 pixeles en la imagen de salida.
\end{itemize}
